package com.yinhe.service.jibeiSync.impl;

import com.yinhe.model.GD_KBXNY;
import com.yinhe.model.SOLAR_WIND_FBS_VO;
import com.yinhe.model.SOLAR_WIND_VO;
import com.yinhe.model.jibeiPO.*;
import com.yinhe.service.jibeiSync.IJiBeiService;
import com.yinhe.util.RedisUtils;
import com.yinhe.util.jibeiSync.DateTimeUtil;
import com.yinhe.util.jibeiSync.FileReadUtil;
import com.yinhe.util.jibeiSync.UUIDUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.nio.file.Files;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @ClassName IJiBeiServiceImpl
 * @Description
 * @Author xiaolongZzz66
 * @Time 2023/12/5 14:05
 * @Version 1.0
 */

@Service
@Slf4j
public class IJiBeiServiceImpl implements IJiBeiService {

    @Autowired
    private RedisUtils redisUtils;

    @Value("${jibei.windAndSolarPath}")
    private String windAndSolarPath;




    @Value("${jibei.windAndSolarPath10Day}")
    private String windAndSolarPath10Day;

    @Value("${jibei.filePath}")
    private String filePath;

    @Value("${jibei.NEW_WINDFORECASTPREFIX}")
    private String new_windForecastPrefix;

    @Value("${jibei.NEW_SOLARFORECASTPREFIX}")
    private String new_solarForecastPrefix;

    @Value("${jibei.NEW_SOLARFORECASTPREFIX_FBS}")
    private String new_solarFbsForecastPrefix;

    @Value("${jibei.NEW_WINDANDSOLARPATH}")
    private String windAndSolarFilePath_new;

    @Value("${jibei.SOLARFORECASTPREFIX10DAY}")
    public String SOLARFORECASTPREFIX10DAY;

    @Value("${jibei.GDKBXNY}")
    private String GDKBXNYPath;

    @Value("${jibei.GDKBXNYPrefix}")
    private String GDKBXNYPrefix;

    /**
     * 删除磁盘文件，删除10天前的磁盘文件
     * @return
     */
    public void deleteDirAndFiles() throws IOException {
        // 获取磁盘文件夹下文件列表
        File dir = new File(filePath);
        File[] listFiles = dir.listFiles();
        // 获取当期系统时间前7天日期
        LocalDate todayBefore10d = DateTimeUtil.getTodayBefore10d();
        if (listFiles!=null){
            for (File file : listFiles) {
                String fileName = file.getName();
                LocalDateTime localDateTime = DateTimeUtil.IsoStringToLocateDate(fileName);
                LocalDate localDate = localDateTime.toLocalDate();
                if (file.isDirectory()&&localDate.isBefore(todayBefore10d)){
                    deleteChildrenDir(file);
                    // Files.delete(file.toPath());
                    // System.out.println(file.toPath());
                    log.info("删除文件为："+ file.toPath());
                }
            }
        }

    }



    /**
     * 删除磁盘文件，删除5天前的磁盘文件
     * @return
     */
    public void deleteDirAndFilesFiveDay() throws IOException {
        // 获取磁盘文件夹下文件列表
        File dir = new File(filePath);
        File[] listFiles = dir.listFiles();
        // 获取当期系统时间前7天日期
        LocalDate todayBefore10d = DateTimeUtil.getTodayBefore10d();
        if (listFiles!=null){
            for (File file : listFiles) {
                String fileName = file.getName();
                LocalDateTime localDateTime = DateTimeUtil.IsoStringToLocateDate(fileName);
                LocalDate localDate = localDateTime.toLocalDate();
                if (file.isDirectory()&&localDate.isBefore(todayBefore10d)){
                    deleteChildrenDir(file);
                    // Files.delete(file.toPath());
                    // System.out.println(file.toPath());
                    log.info("删除文件为："+ file.toPath());
                }
            }
        }

    }

    /**
     * 递归删除文件
     */
    public void deleteChildrenDir(File file) throws IOException {
        if (file.isDirectory()){
            File[] files = file.listFiles();
            for (File file1 : files) {
                deleteChildrenDir(file1);
            }
        }

        Files.delete(file.toPath());
    }


    /**
     * 新能源多路短路比
     * @param fileName
     * @param tableName
     * @desction 分类取最小值
     * @return
     */
    @Override
    public List<DSA_XNY_DLB_UN_PO> selectXNY(String fileName, String tableName, String nowNmaeTime) {
        // 1、获取redis中时间标识，根据时间标识（上一次同步时间）计算本次同步的时间标识（文件夹名）；
        // 2、根据文件名和表名取获取当前表所有数据。
        // 3、根据统计规则，获取所需要的数据并返回。
        // 4、修改redis中当前表的标识为上面计算的时间。
        // LocalDateTime lastSyncTime =  DateTimeUtil.StringToLocateDate("2023-11-29 15:00:00");
        // String time = DateTimeUtil.getIso8601NameByLocateDate(lastSyncTime);
        // redisUtils.set(tableName, time);
        // String nowNmaeTime = (String) redisUtils.get(tableName);

        // 解析文件，获取数据
        List<DSA_XNY_DLB_UN_PO> list = FileReadUtil.parseDir(fileName, tableName, nowNmaeTime,DSA_XNY_DLB_UN_PO.class,filePath);

        //对数据进行统计
        Map<String,List<DSA_XNY_DLB_UN_PO>> group = new HashMap<>();
        if(list!=null&&list.size()>0){
            // 分类
            for (DSA_XNY_DLB_UN_PO po : list) {
                String areaname = po.getAreaname();
                List<DSA_XNY_DLB_UN_PO> mapValue = group.get(areaname);
                if (mapValue==null){
                    List<DSA_XNY_DLB_UN_PO> list1 = new ArrayList<>();
                    list1.add(po);
                    group.put(areaname, list1);
                }else {
                    // 判断，如果极端短路比大于存在的一条数据，再替换(如此只存放最小值)
                    if (Double.parseDouble(po.getMscr()) < Double.parseDouble(mapValue.get(0).getMscr())){
                        mapValue.clear();
                        mapValue.add(po);
                    }
                }
            }
        }

        // 返回map的所有值到一个list中
        String localDateTime = DateTimeUtil.IsoStringToStatandLocateDate(nowNmaeTime);
        List<DSA_XNY_DLB_UN_PO> collect = group.values().stream().flatMap(List::stream).map(s -> {
            s.setHTSDSyncTime(localDateTime);
            s.setHTSDUuid(UUIDUtil.getUuid());
            return s;
        }).collect(Collectors.toList());

        // // 成功设置下一次redis中读取时间
        // String nextReadTime = getNextReadTime(localDateTime);
        // redisUtils.set(tableName, nextReadTime);
        return collect;
    }


    /**
     * 新能源多路短路比(全部场站数据)
     * @param fileName
     * @param tableName
     * @desction
     * @return
     */
    @Override
    public List<DSA_XNY_DLB_UN_PO> selectXNYAllPosition(String fileName, String tableName, String nowNmaeTime) {
        // 解析文件，获取数据
        List<DSA_XNY_DLB_UN_PO> list = FileReadUtil.parseDir(fileName, tableName, nowNmaeTime,DSA_XNY_DLB_UN_PO.class,filePath);

        // 返回map的所有值到一个list中
        String localDateTime = DateTimeUtil.IsoStringToStatandLocateDate(nowNmaeTime);

        if (!CollectionUtils.isEmpty(list)){
            for (DSA_XNY_DLB_UN_PO po : list) {
                po.setHTSDSyncTime(localDateTime);
            }
        }

        return list;
    }


    /**
     * 稳定裕度分析
     * @param fileName
     * @param tableName
     * @return
     */
    @Override
    public List<TTCOutput_PO> selectPhase(String fileName, String tableName, String nowNmaeTime) {
        // 1、根据table表名去获取标识时间
        // LocalDateTime lastSyncTime =  DateTimeUtil.StringToLocateDate("2023-11-29 15:00:00");
        // String time = DateTimeUtil.getIso8601NameByLocateDate(lastSyncTime);
        // redisUtils.set(tableName, time);
        // String nowNmaeTime = (String) redisUtils.get(tableName);

        // 解析文件，获取数据
        List<TTCOutput_PO> list = FileReadUtil.parseDir(fileName, tableName, nowNmaeTime,TTCOutput_PO.class,filePath);

        // 处理文件，进行统计（这里每个断面最多一条，不需要做特殊处理，直接存起来）
        String localDateTime = DateTimeUtil.IsoStringToStatandLocateDate(nowNmaeTime);
        if(list!=null&&list.size()>0){
            list.stream().map(s -> { s.setHTSDSyncTime(localDateTime);s.setHTSDUuid(UUIDUtil.getUuid());return s;}).collect(Collectors.toList());
        }

        // 成功设置下一次redis中读取时间
        // String nextReadTime = getNextReadTime(localDateTime);
        // redisUtils.set(tableName, nextReadTime);
        return list;
    }

    /**
     * 最大越限百分比
     * @param fileName
     * @param tableName
     * @return
     */
    @Override
    public List<SAOUT_OVER_PO> selectPSQSOutLimitRate(String fileName, String tableName, String nowNmaeTime) {
        // 解析文件，获取数据
        List<SAOUT_OVER_PO> list = FileReadUtil.parseDir(fileName, tableName, nowNmaeTime,SAOUT_OVER_PO.class,filePath);

        // 统计处理（这里直接去Perc最大值）
        String localDateTime = DateTimeUtil.IsoStringToStatandLocateDate(nowNmaeTime);
        if (list!=null&&list.size()>0){
            SAOUT_OVER_PO saout_over_po = list.stream().max(Comparator.comparing(SAOUT_OVER_PO::getPerc))
                    .map(s -> {
                        s.setHTSDSyncTime(localDateTime);
                        s.setHTSDUuid(UUIDUtil.getUuid());
                        return s;
                    }).orElse(null);
            list.clear();
            if (saout_over_po!=null){
                list.add(saout_over_po);
            }
        }

        // 成功设置下一次redis中读取时间
        // String nextReadTime = getNextReadTime(localDateTime);
        // redisUtils.set(tableName, nextReadTime);
        return list;
    }

    /**
     * 电压稳定分析（xiaolong66）
     * @param fileName
     * @param tableName
     * @return
     */
    @Override
    public List<GD_VSOUT_PO> selectPSQSVoltageStabilityAnaly(String fileName, String tableName, String nowNmaeTime) {

        // 1、根据table表名去获取标识时间
        // LocalDateTime lastSyncTime =  DateTimeUtil.StringToLocateDate("2023-11-29 15:00:00");
        // String time = DateTimeUtil.getIso8601NameByLocateDate(lastSyncTime);
        // redisUtils.set(tableName, time);
        // String nowNmaeTime = (String) redisUtils.get(tableName);

        // 解析文件，获取数据
        List<GD_VSOUT_PO> list = FileReadUtil.parseDir(fileName, tableName, nowNmaeTime,GD_VSOUT_PO.class,filePath);

        // 统计处理（这里直接去vsl最大值）
        String localDateTime = DateTimeUtil.IsoStringToStatandLocateDate(nowNmaeTime);
        if (list!=null&&list.size()>0){
            GD_VSOUT_PO gd_vsout_po =
                    list.stream().max(Comparator.comparing(GD_VSOUT_PO -> Double.parseDouble(GD_VSOUT_PO.getVsl()))).map(s -> {
                s.setHTSDSyncTime(localDateTime);
                s.setHTSDUuid(UUIDUtil.getUuid());
                return s;
            }).orElse(null);

            list.clear();
            if(gd_vsout_po!=null){
                list.add(gd_vsout_po);
            }
        }

        // 成功设置下一次redis中读取时间
        // String nextReadTime = getNextReadTime(localDateTime);
        // redisUtils.set(tableName, nextReadTime);
        return list;
    }

    /**
     * 最低阻尼比-小干扰分析(xiaolong66)
     * @param fileName
     * @param tableName
     * @return
     */
    @Override
    public List<SSTOUT_PO> selectPSQSDampingMin(String fileName, String tableName, String nowNmaeTime) {

        // 解析文件，获取数据
        List<SSTOUT_PO> list = FileReadUtil.parseDir(fileName, tableName, nowNmaeTime,SSTOUT_PO.class,filePath);

        // 统计处理（这里直接去al最小值）
        String localDateTime = DateTimeUtil.IsoStringToStatandLocateDate(nowNmaeTime);
        if (list!=null&&list.size()>0){
            SSTOUT_PO sstout_po = list.stream().min(Comparator.comparing(SSTOUT_PO -> Double.parseDouble(SSTOUT_PO.getAl()))).map(s -> {
                s.setHTSDSyncTime(localDateTime);
                s.setHTSDUuid(UUIDUtil.getUuid());
                return s;
            }).orElse(null);

            list.clear();
            if(sstout_po!=null){
                list.add(sstout_po);
            }
        }

        // 成功设置下一次redis中读取时间
        // String nextReadTime = getNextReadTime(localDateTime);
        // redisUtils.set(tableName, nextReadTime);
        return list;
    }

    /**
     * 三相单相最大短路电流
     * @param fileName 文件名
     * @param tableName 表名
     * @param nowNmaeTime 时刻值
     * @return
     */
    @Override
    public List<SCCOUT_PO> selectPSQSShortCircuitMax(String fileName, String tableName, String nowNmaeTime) {

        // 1、根据table表名去获取标识时间
        // LocalDateTime lastSyncTime =  DateTimeUtil.StringToLocateDate("2023-11-29 15:00:00");
        // String time = DateTimeUtil.getIso8601NameByLocateDate(lastSyncTime);
        // redisUtils.set(tableName, time);
        // String nowNmaeTime = (String) redisUtils.get(tableName);

        // 解析文件，获取数据
        List<SCCOUT_PO> list = FileReadUtil.parseDir(fileName, tableName, nowNmaeTime,SCCOUT_PO.class,filePath);


        // 统计处理（这里直接去FaultCurrent最大值）
        Map<String,List<SCCOUT_PO>> group = new HashMap<>();
        if (list!=null&&list.size()>0){
            // 分类
            for (SCCOUT_PO po : list) {
                String shortType = po.getShortType();
                List<SCCOUT_PO> mapValue = group.get(shortType);
                if (mapValue==null){
                    List<SCCOUT_PO> list1 = new ArrayList<>();
                    list1.add(po);
                    group.put(shortType, list1);
                }else {
                    // 判断，最大值
                    if (Double.parseDouble(po.getFaultCurrent()) > Double.parseDouble(mapValue.get(0).getFaultCurrent())){
                        mapValue.clear();
                        mapValue.add(po);
                    }
                }
            }
        }

        // 返回map的所有值到一个list中
        String localDateTime = DateTimeUtil.IsoStringToStatandLocateDate(nowNmaeTime);

        List<SCCOUT_PO> collect = group.values().stream().flatMap(List::stream).map(s -> {
            s.setHTSDSyncTime(localDateTime);
            s.setHTSDUuid(UUIDUtil.getUuid());
            return s;
        }).collect(Collectors.toList());

        // 成功设置下一次redis中读取时间
        // String nextReadTime = getNextReadTime(localDateTime);
        // redisUtils.set(tableName, nextReadTime);
        return collect;
    }

    /**
     * 暂态稳定分析--最大公交差、最低电压(两表合一，新增一个标识位（selfType），用来区分那条是最大功角差power，那条是最低电压voltage)
     * @param fileName
     * @param tableName
     * @return
     */
    @Override
    public List<GD_STOUT_PO> selectPSQSPowerAngleMax(String fileName, String tableName, String nowNmaeTime) {
        // 1、根据table表名去获取标识时间
        // LocalDateTime lastSyncTime =  DateTimeUtil.StringToLocateDate("2023-11-29 15:00:00");
        // String time = DateTimeUtil.getIso8601NameByLocateDate(lastSyncTime);
        // redisUtils.set(tableName, time);
        // String nowNmaeTime = (String) redisUtils.get(tableName);

        // 解析文件，获取数据
        List<GD_STOUT_PO> list = FileReadUtil.parseDir(fileName, tableName, nowNmaeTime,GD_STOUT_PO.class,filePath);

        // 统计处理（这里直接去gena_max_crit 最大功角差最大值）
        String localDateTime = DateTimeUtil.IsoStringToStatandLocateDate(nowNmaeTime);
        if (list!=null&&list.size()>0){
            // 最大功角差
            // GD_STOUT_PO gd_stout_po = list.stream().max(Comparator.comparing(GD_STOUT_PO -> Double.parseDouble(GD_STOUT_PO.getGena_max_crit()))).map(s -> {
            //     s.setHTSDSyncTime(localDateTime);
            //     s.setSelfType("power");
            //     s.setHTSDUuid(UUIDUtil.getUuid());
            //     return s;
            // }).orElse(null);

            GD_STOUT_PO gd_stout_po = list.stream().max(Comparator.comparing(GD_STOUT_PO -> Double.parseDouble(GD_STOUT_PO.getGena_max_crit()))).orElse(null);

            // 最小电压
            // GD_STOUT_PO gd_stout_po2 = list.stream().min(Comparator.comparing(GD_STOUT_PO -> Double.parseDouble(GD_STOUT_PO.getVol_min_crit()))).map(s -> {
            //     s.setHTSDSyncTime(localDateTime);
            //     s.setSelfType("voltage");
            //     s.setHTSDUuid(UUIDUtil.getUuid());
            //     return s;
            // }).orElse(null);

            GD_STOUT_PO gd_stout_po2 = list.stream().min(Comparator.comparing(GD_STOUT_PO -> Double.parseDouble(GD_STOUT_PO.getVol_min_crit()))).orElse(null);


            list.clear();
            if (gd_stout_po!=null){
                GD_STOUT_PO gd_stout_po_cope = new GD_STOUT_PO();
                BeanUtils.copyProperties(gd_stout_po, gd_stout_po_cope);
                gd_stout_po_cope.setHTSDSyncTime(localDateTime);
                gd_stout_po_cope.setSelfType("power");
                gd_stout_po_cope.setHTSDUuid(UUIDUtil.getUuid());
                list.add(gd_stout_po_cope);
            }
            if (gd_stout_po2!=null){
                GD_STOUT_PO gd_stout_po_cope = new GD_STOUT_PO();
                BeanUtils.copyProperties(gd_stout_po2, gd_stout_po_cope);
                gd_stout_po_cope.setHTSDSyncTime(localDateTime);
                gd_stout_po_cope.setSelfType("voltage");
                gd_stout_po_cope.setHTSDUuid(UUIDUtil.getUuid());
                list.add(gd_stout_po_cope);
            }
        }

        // 成功设置下一次redis中读取时间
        // String nextReadTime = getNextReadTime(localDateTime);
        // redisUtils.set(tableName, nextReadTime);
        return list;
    }


    /**
     * 下一次读取时间
     * @param time
     * @return
     */
    private String getNextReadTime(String time){
        LocalDateTime lastSyncTime =  DateTimeUtil.StringToLocateDate(time);
        String nextTime = DateTimeUtil.getIso8601NameByLocateDate(lastSyncTime);
        return nextTime;
    }



    /**
     * 读取风力和光能预测数据10h（分布式光伏+集中式光伏+风能）
     * @return
     */
    @Override
    public List<SOLAR_WIND_FBS_VO> selectWindAndSolarForecast() {
        // 获取风力文件名
        Map<String,  LocalDateTime> windMap =  FileReadUtil.parseWindAndSolarFile(windAndSolarPath,FileReadUtil.WINDFORECASTPREFIX);

        List<WIND_PO> windPos = new ArrayList<>();
        List<SOLAR_PO> solarPos = new ArrayList<>();
        List<SOLAR_PO> solarPosFbs = new ArrayList<>();

        if (!windMap.isEmpty()){
            for (String key : windMap.keySet()) {
                windPos = FileReadUtil.parseWindAndSolarFileConten(new File(key), windMap.get(key), WIND_PO.class);
            }
        }

        // 获取光伏文件名--(集中式，分布式)
        Map<String,  LocalDateTime> solarMap =   FileReadUtil.parseWindAndSolarFile(windAndSolarPath,FileReadUtil.SOLARFORECASTPREFIX);
        if (!solarMap.isEmpty()){
            for (String key : solarMap.keySet()) {
                solarPos = FileReadUtil.parseWindAndSolarFileConten(new File(key), solarMap.get(key), SOLAR_PO.class);
            }
        }

        // 获取光伏文件名--分布式
        Map<String,  LocalDateTime> solarMapFbs = FileReadUtil.parseWindAndSolarFile(windAndSolarPath,FileReadUtil.SOLARFORECASTPREFIX_FBS);
        if (!solarMapFbs.isEmpty()){
            for (String key : solarMapFbs.keySet()) {
                solarPosFbs = FileReadUtil.parseWindAndSolarFileConten(new File(key), solarMapFbs.get(key), SOLAR_PO.class);
            }
        }

        // 获取所有的时刻值,所有的key（分布式的只有4个小时，我们只需要四个小时内的风能光伏数据）
        Set<String> AllTime = new HashSet<>();

        // 获取wind的  时刻--》PO 对象
        Map<String, WIND_PO> windPoMap = new HashMap<>();
        if (!CollectionUtils.isEmpty(windPos)){
            windPoMap = windPos.stream().collect(Collectors.toMap(WIND_PO::getTimePoint, wind_po -> wind_po));
            // AllTime.addAll(windPoMap.keySet().stream().collect(Collectors.toSet()));
        }

        // 获取solar的(集中式)  时刻--》PO 对象
        Map<String, SOLAR_PO> solarPoMap = new HashMap<>();
        if(!CollectionUtils.isEmpty(solarPos)){
            solarPoMap = solarPos.stream().collect(Collectors.toMap(SOLAR_PO::getTimePoint, solar_po -> solar_po));
            // AllTime.addAll(solarPoMap.keySet().stream().collect(Collectors.toSet()));
        }

        // 获取solar的(分布式)  时刻--》PO 对象
        Map<String, SOLAR_PO> solarPoMapFbs = new HashMap<>();
        if(!CollectionUtils.isEmpty(solarPosFbs)){
            solarPoMapFbs = solarPosFbs.stream().collect(Collectors.toMap(SOLAR_PO::getTimePoint, solar_po -> solar_po));
            AllTime.addAll(solarPoMapFbs.keySet().stream().collect(Collectors.toSet()));
        }

        List<SOLAR_WIND_FBS_VO> swvo = new ArrayList<>();
        if(AllTime.size()>0){
            for (String itemTime : AllTime) {
                WIND_PO windPo = windPoMap.get(itemTime);
                SOLAR_PO solarPo = solarPoMap.get(itemTime);
                SOLAR_PO solarFbsPo = solarPoMapFbs.get(itemTime);
                SOLAR_WIND_FBS_VO vo = new SOLAR_WIND_FBS_VO();
                //风能功率
                if(windPo!=null){
                    vo.setWindNum(Double.parseDouble(windPo.getValue()));
                }

                // 分布式和集中式光伏功率
                if (solarPo!=null){
                    vo.setSolarNum(Double.parseDouble(solarPo.getValue()));
                }

                if (solarFbsPo!=null){
                    vo.setSolarFbsNum(Double.parseDouble(solarFbsPo.getValue()));
                }

                vo.setTimePoint(itemTime);
                swvo.add(vo);
            }
        }
        // return swvo;
        return swvo.stream().sorted(Comparator.comparing(SOLAR_WIND_VO::getTimePoint)).collect(Collectors.toList());
    }




    /**
     * 读取风力和光能预测数据10h最新接入--2024-0320（分布式光伏+集中式光伏+风能）
     * @return
     */
    @Override
    public List<SOLAR_WIND_FBS_VO> selectWindAndSolarForecastShortTimeNew() {
        // 获取风力文件名
        Map<String,  LocalDateTime> windMap =  FileReadUtil.parseWindAndSolarFile(windAndSolarFilePath_new,new_windForecastPrefix);

        List<WIND_PO> windPos = new ArrayList<>();
        List<SOLAR_PO> solarPos = new ArrayList<>();
        List<SOLAR_PO> solarPosFbs = new ArrayList<>();

        if (!windMap.isEmpty()){
            for (String key : windMap.keySet()) {
                windPos = FileReadUtil.parseWindAndSolarFileConten(new File(key), windMap.get(key), WIND_PO.class);
            }
        }

        // 获取光伏文件名--(集中式，分布式)
        Map<String,  LocalDateTime> solarMap =   FileReadUtil.parseWindAndSolarFile(windAndSolarFilePath_new,new_solarForecastPrefix);
        if (!solarMap.isEmpty()){
            for (String key : solarMap.keySet()) {
                solarPos = FileReadUtil.parseWindAndSolarFileConten(new File(key), solarMap.get(key), SOLAR_PO.class);
            }
        }

        // // 获取光伏文件名--分布式
        // Map<String,  LocalDateTime> solarMapFbs = FileReadUtil.parseWindAndSolarFile(windAndSolarFilePath_new,new_solarFbsForecastPrefix);
        // if (!solarMapFbs.isEmpty()){
        //     for (String key : solarMapFbs.keySet()) {
        //         solarPosFbs = FileReadUtil.parseWindAndSolarFileConten(new File(key), solarMapFbs.get(key), SOLAR_PO.class);
        //     }
        // }

        // 获取所有的时刻值,所有的key（分布式的只有4个小时，我们只需要四个小时内的风能光伏数据）
        Set<String> AllTime = new HashSet<>();

        // 获取wind的  时刻--》PO 对象
        Map<String, WIND_PO> windPoMap = new HashMap<>();
        if (!CollectionUtils.isEmpty(windPos)){
            windPoMap = windPos.stream().collect(Collectors.toMap(WIND_PO::getTimePoint, wind_po -> wind_po));
            // AllTime.addAll(windPoMap.keySet().stream().collect(Collectors.toSet()));
        }

        // 获取solar的(集中式,分布式)  时刻--》PO 对象
        Map<String, SOLAR_PO> solarPoMap = new HashMap<>();
        if(!CollectionUtils.isEmpty(solarPos)){
            solarPoMap = solarPos.stream().collect(Collectors.toMap(SOLAR_PO::getTimePoint, solar_po -> solar_po));
            AllTime.addAll(solarPoMap.keySet().stream().collect(Collectors.toSet()));
        }

        // 获取solar的(分布式)  时刻--》PO 对象
        // Map<String, SOLAR_PO> solarPoMapFbs = new HashMap<>();
        // if(!CollectionUtils.isEmpty(solarPosFbs)){
        //     solarPoMapFbs = solarPosFbs.stream().collect(Collectors.toMap(SOLAR_PO::getTimePoint, solar_po -> solar_po));
        //     // AllTime.addAll(solarPoMapFbs.keySet().stream().collect(Collectors.toSet()));
        // }

        List<SOLAR_WIND_FBS_VO> swvo = new ArrayList<>();
        if(AllTime.size()>0){
            for (String itemTime : AllTime) {
                WIND_PO windPo = windPoMap.get(itemTime);
                SOLAR_PO solarPo = solarPoMap.get(itemTime);
                // SOLAR_PO solarFbsPo = solarPoMapFbs.get(itemTime);
                SOLAR_WIND_FBS_VO vo = new SOLAR_WIND_FBS_VO();
                //风能功率
                if(windPo!=null){
                    vo.setWindNum(Double.parseDouble(windPo.getValue()));
                }

                // 分布式和集中式光伏功率
                if (solarPo!=null){
                    vo.setSolarNum(Double.parseDouble(solarPo.getValue()));
                }

                // if (solarFbsPo!=null){
                //     vo.setSolarFbsNum(Double.parseDouble(solarFbsPo.getValue()));
                // }

                vo.setTimePoint(itemTime);
                swvo.add(vo);
            }
        }
        // return swvo;
        return swvo.stream().sorted(Comparator.comparing(SOLAR_WIND_VO::getTimePoint)).collect(Collectors.toList());
    }

    /**
     * 读取风力和光能预测数据未来10天的预测（风能+光伏（是集中式和分布式的总加文件））
     * @return
     */
    @Override
    public List<SOLAR_WIND_VO> selectWindAndSolarForecast10day() {

        List<WIND_PO> windPos = new ArrayList<>();
        List<SOLAR_PO> solarPos = new ArrayList<>();

        // 获取风能10天数据
        Map<String, LocalDateTime> windMap = FileReadUtil.parseWindAndSolar10dayFile(windAndSolarPath10Day, FileReadUtil.WINDFORECASTPREFIX10DAY);
        if (windMap!=null){
            for (String key : windMap.keySet()) {
                windPos = FileReadUtil.parseWindAndSolar10dayFileConten(new File(key), windMap.get(key), WIND_PO.class);
            }
        }
        // 获取光伏10天数据
        Map<String, LocalDateTime> solarMap = FileReadUtil.parseWindAndSolar10dayFile(windAndSolarPath10Day, SOLARFORECASTPREFIX10DAY);
        if (solarMap!=null){
            for (String key : solarMap.keySet()) {
                solarPos = FileReadUtil.parseWindAndSolar10dayFileConten(new File(key), solarMap.get(key), SOLAR_PO.class);
            }
        }

        // 获取所有的时刻值,所有的key
        Set<String> AllTime = new HashSet<>();
        // 获取wind的  时刻--》PO 对象
        Map<String, WIND_PO> windPoMap = new HashMap<>();
        if (!CollectionUtils.isEmpty(windPos)){
            windPoMap = windPos.stream().collect(Collectors.toMap(WIND_PO::getTimePoint, wind_po -> wind_po));
            AllTime.addAll(windPoMap.keySet().stream().collect(Collectors.toSet()));
        }
        // 获取solar的  时刻--》PO 对象
        Map<String, SOLAR_PO> solarPoMap = new HashMap<>();
        if(!CollectionUtils.isEmpty(solarPos)){
            solarPoMap = solarPos.stream().collect(Collectors.toMap(SOLAR_PO::getTimePoint, solar_po -> solar_po));
            AllTime.addAll(solarPoMap.keySet().stream().collect(Collectors.toSet()));
        }

        List<SOLAR_WIND_VO> swvo = new ArrayList<>();
        if(AllTime.size()>0){
            for (String itemTime : AllTime) {
                WIND_PO wind = windPoMap.get(itemTime);
                SOLAR_PO solar = solarPoMap.get(itemTime);
                SOLAR_WIND_VO vo = new SOLAR_WIND_VO();
                //换掉 value -----------------------------------------------------------------------------
                if(wind!=null){
                    vo.setWindNum(Double.parseDouble(wind.getValue()));
                }
                if (solar!=null){
                    vo.setSolarNum(Double.parseDouble(solar.getValue()));
                }
                vo.setTimePoint(itemTime);
                swvo.add(vo);
            }
        }
        // return swvo;
        return swvo.stream().sorted(Comparator.comparing(SOLAR_WIND_VO::getTimePoint)).collect(Collectors.toList());
    }

    /**
     * 冀北全网断面受阻预测gd_qwdmsz
     * @return
     */
    @Override
    public List<GD_KBXNY> selectGDKBXNY() throws ClassNotFoundException, InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        // 1、解析获取最新文件名。
        // 2、根据文件名绝对路径取读取文件，并且解析出内容。
        // 3、将内容处理为需要的数据
        List<GD_KBXNY> gdKbxnyList = new ArrayList<>();
        Map<String, LocalDateTime> gdkbxnyFileNameMap = FileReadUtil.parseGDKBXNYFileName(GDKBXNYPath, GDKBXNYPrefix, "getGDKBXNYFileNameTime");
        if (gdkbxnyFileNameMap!=null){
            for (String key : gdkbxnyFileNameMap.keySet()) {
                gdKbxnyList = FileReadUtil.parseGDXNYFileConten(new File(key), gdkbxnyFileNameMap.get(key), GD_KBXNY.class);
            }
        }
        return gdKbxnyList;
    }

    @Override
    public List<GD_SAOUT_PO> selectGDSAOUTLimitRate(String fileName, String tableName, String nowNmaeTime) {
        // 解析文件，获取数据
        List<GD_SAOUT_PO> list = FileReadUtil.parseDir(fileName, tableName, nowNmaeTime,GD_SAOUT_PO.class,filePath);

        // 统计处理（这里直接去Perc最大值）
        String localDateTime = DateTimeUtil.IsoStringToStatandLocateDate(nowNmaeTime);
        if (list!=null&&list.size()>0){
            // case_no为0是代表基态越限，要把基态越限去掉取最大值
            GD_SAOUT_PO gd_saout_po = list.stream().filter(gd_saout_po1 -> !"0".equals(gd_saout_po1.getCase_No())).max(Comparator.comparing(gd_saout_po1 -> Double.parseDouble(gd_saout_po1.getFault_current())))
                    .map(s -> {
                        s.setHTSDSyncTime(localDateTime);
                        return s;
                    }).orElse(null);
            list.clear();
            if (gd_saout_po!=null){
                list.add(gd_saout_po);
            }
        }
        return list;
    }



    /**
     * 三相单相最大短路电流NEW(xiaolong)
     * @param fileName 文件名
     * @param tableName 表名
     * @param nowNmaeTime 时刻值
     * @return
     */
    @Override
    public List<GD_SCCOUT_PO> selectPSQSShortCircuitMaxNEW(String fileName, String tableName, String nowNmaeTime) {

        // 解析文件，获取数据
        List<GD_SCCOUT_PO> list = FileReadUtil.parseDir(fileName, tableName, nowNmaeTime,GD_SCCOUT_PO.class,filePath);

        // 统计处理（这里直接去FaultCurrent最大值）
        Map<String,List<GD_SCCOUT_PO>> group = new HashMap<>();
        if (list!=null&&list.size()>0){
            // 分类
            for (GD_SCCOUT_PO po : list) {
                String shortType = po.getShorttype();
                List<GD_SCCOUT_PO> mapValue = group.get(shortType);
                if (mapValue==null){
                    List<GD_SCCOUT_PO> list1 = new ArrayList<>();
                    list1.add(po);
                    group.put(shortType, list1);
                }else {
                    // 判断，最大值
                    if (Double.parseDouble(po.getFaultcurrent()) > Double.parseDouble(mapValue.get(0).getFaultcurrent())){
                        mapValue.clear();
                        mapValue.add(po);
                    }
                }
            }
        }

        // 返回map的所有值到一个list中
        String localDateTime = DateTimeUtil.IsoStringToStatandLocateDate(nowNmaeTime);

        List<GD_SCCOUT_PO> collect = group.values().stream().flatMap(List::stream).map(s -> {
            s.setHTSDSyncTime(localDateTime);
            return s;
        }).collect(Collectors.toList());

        return collect;
    }


}
